import * as Cesium from '@cesium/Source/Cesium.js';
import FourPrismGeometry from './FourPrismGeometry';
import {
  computeVertexNormals
} from './computeVertexNormals';
import * as turf from '@turf/turf';

var extend2CartesianArray, SatelliteCoverageSimulation;

(function() {
  "use strict";

  function n(t, e) {
    e = e || {},
      a = t.scene.globe.ellipsoid,
      this._geometry = null,
      this._areaType = e.areaType ? e.areaType : n.AreaType.FourPrism,
      this._angle1 = e.angle1 ? e.angle1 : 10,
      this._angle2 = e.angle2 ? e.angle2 : 10,
      this._length = e.length ? e.length : 1e6,
      this._position = e.position, this.autoAngle = e.autoAngle,
      this._rotation = e.rotation ? e.rotation : {
        heading: 0,
        pitch: 0,
        roll: 0
      },
      this._show = Cesium.defaultValue(e.show, !0),
      this._outline = Cesium.defaultValue(e.outline, !1),
      this._groundArea = Cesium.defaultValue(e.groundArea, !1),
      this._groundOutLine = Cesium.defaultValue(e.groundOutLine, !1),
      this.defaultColor = e.color ? e.color : Cesium.Color.YELLOW,
      this.defaultLineColor = e.lineColor, this._groundAreaColor = e.groundAreaColor,
      this._groundOutLineColor = e.groundOutLineColor,
      this._modelMatrix = Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY),
      this._quaternion = new Cesium.Quaternion,
      this._translation = new Cesium.Cartesian3,
      this._scale = new Cesium.Cartesian3(1, 1, 1),
      this._matrix = new Cesium.Matrix4,
      this._inverseMatrix = new Cesium.Matrix4,
      this._positionCartographic = new Cesium.Cartographic,
      this._positionCartesian = null,
      this._drawCommands = [],
      this._outlinePositions = [],
      this._imagingAreaPositions = [],
      this._trackedEntity = e.trackedEntity,
      this._trackPositions = [],
      this._trackGeometries = [],
      this._track = {
        geometry: null,
        needsUpdate: !1,
        lastestFrame: null
      },
      this.viewer = t,
      this.viewer.scene.primitives.add(this),
      this.addGroundAreaEntity(this._groundArea || this._groundOutLine)
  }

  function r(t) {
    var e = [];
    for (var i in t.attributes)
      t.attributes.hasOwnProperty(i) && t.attributes[i] && e.push(i);
    return e
  }

  function o(t, e, i, n, r, o, a) {
    r = r || Cesium.Ellipsoid.WGS84, o || (o = []),
      Cesium.Matrix4.inverse(e, m),
      Cesium.Matrix4.multiplyByPoint(e, Cesium.Cartesian3.ZERO, p),
      p.clone(c.origin);
    var s = 0;
    n = Math.min(t.length, i + n);
    for (var l = i; l < n; l += 3) {
      Cesium.Cartesian3.unpack(t, l, f),
        Cesium.Matrix4.multiplyByPoint(e, f, p),
        Cesium.Cartesian3.subtract(p, c.origin, c.direction),
        Cesium.Cartesian3.normalize(c.direction, c.direction);
      var h = Cesium.IntersectionTests.rayEllipsoid(c, r),
        d = null;
      h && (d = Cesium.Ray.getPoint(c, h.start)), d ? (d.clone(p), o[s] = p.clone(o[s]), a &&
        a instanceof Float32Array && (Cesium.Matrix4.multiplyByPoint(m, p, p), a[i + 3 * s] = p.x, a[i + 3 * s +
          1] = p.y, a[i + 3 * s + 2] = p.z), s++) : s++
    }
    return o
  }
  // Object.defineProperty(Cesium, "__esModule", {
  //     value: !0
  //   }),
  //   Cesium.SatelliteCoverageSimulation = void 0;
  var a,
    m = new Cesium.Matrix4,
    f = new Cesium.Cartesian3,
    p = new Cesium.Cartesian3,
    c = new Cesium.Ray,
    _ = new Cesium.Cartographic;
  n.AreaType = {
      Cone: 1,
      FourPrism: 2
    },
    Object.defineProperties(n.prototype, {
      color: {
        get: function() {
          return this.defaultColor
        },
        set: function(t) {
          this.defaultColor = t
        }
      },
      lineColor: {
        get: function() {
          return this.defaultLineColor
        },
        set: function(t) {
          this.defaultLineColor = t
        }
      },
      trackedEntity: {
        get: function() {
          return this._trackedEntity
        },
        set: function(t) {
          t != this._trackedEntity && (this.position = t.position),
            this._trackedEntity = t
        }
      },
      show: {
        get: function() {
          return this._show
        },
        set: function(t) {
          this._show = t
        }
      },
      outline: {
        get: function() {
          return this._outline
        },
        set: function(t) {
          this._outline = t
        }
      },
      angle1: {
        get: function() {
          return this._angle1
        },
        set: function(t) {
          this._angle1 = t,
            this.clearCommands(),
            this._geometry = null
        }
      },
      angle2: {
        get: function() {
          return this._angle2
        },
        set: function(t) {
          this._angle2 = t,
            this.clearCommands(),
            this._geometry = null
        }
      },
      areaType: {
        get: function() {
          return this._areaType
        },
        set: function(t) {
          this._areaType = t,
            this.clearCommands(),
            this._geometry = null
        }
      },
      rotation: {
        get: function() {
          return this._rotation
        },
        set: function(t) {
          this._rotation = t,
            this.clearCommands(),
            this._geometry = null
        }
      },
      heading: {
        get: function() {
          return this._rotation.heading
        },
        set: function(t) {
          this._rotation.heading = t,
            this.clearCommands(),
            this._geometry = null
        }
      },
      pitch: {
        get: function() {
          return this._rotation.pitch
        },
        set: function(t) {
          this._rotation.pitch = t,
            this.clearCommands(),
            this._geometry = null
        }
      },
      roll: {
        get: function() {
          return this._rotation.roll
        },
        set: function(t) {
          this._rotation.roll = t,
            this.clearCommands(),
            this._geometry = null
        }
      },
      position: {
        get: function() {
          return this._position
        },
        set: function(t) {
          this._position = t,
            this._geometry = null,
            this._drawCommands = []
        }
      }
    }),
    n.prototype.addGroundAreaEntity = function(t) {
      if (t && !this.groundAreaEntity) {
        var e = this,
          i = new Cesium.PolygonHierarchy;
        this.groundAreaEntity = this.viewer.entities.add({
          polygon: {
            show: this._groundArea,
            material: this._groundAreaColor || this.defaultColor,
            hierarchy: new Cesium.CallbackProperty(function(t) {
              return i.positions = e._imagingAreaPositions, i
            }, !1)
          },
          polyline: {
            show: this._groundOutLine,
            material: this._groundOutLineColor || this._groundAreaColor || this.defaultColor,
            width: 1.5,
            positions: new Cesium.CallbackProperty(function(t) {
              return e._imagingAreaPositions
            }, !1)
          }
        })
      }
    },
    n.prototype.clearCommands = function() {
      this._drawCommands.forEach(function(t) {
          t.vertexArray.destroy()
        }),
        this._drawCommands = []
    },
    n.prototype.mergeGeometries = function(t, e) {
      if (!t || !t.length)
        throw new Error("缺少geometries参数");
      for (var i = [], n = !1, o = !1, a = t[0].primitiveType, s = 0; s < t.length; s++) {
        if (i[s] = r(t[s]), s > 0) {
          if (a != t[s].primitiveType) {
            o = !0;
            break
          }
          var l = i[s - 1];
          if (!(n = l.length != i[s].length))
            for (var h = 0; h < l.length; h++)
              if (l[h] != i[s][h]) {
                n = !0;
                break
              }
        }
        if (a = t[s].primitiveType, n || o)
          break
      }
      if (o) throw new Error("待合并的几何体中primitiveType属性不完全一致");
      if (n) throw new Error("待合并的几何体中属性数量和和名称不完全一致");
      for (var d = {}, m = i[0], s = 0; s < m.length; s++) {
        var f = m[s],
          p = t[0];
        d[f] = {};
        for (var c in p.attributes[f])
          p.attributes[f].hasOwnProperty(c) && (d[f][c] = p.attributes[f][c]);
        for (var _ = Array.from(d[f].values), h = 1; h < t.length; h++) {
          p = t[h];
          for (var g = 0; g < p.attributes[f].values.length; g++)
            _.push(p.attributes[f].values[g])
        }
        d[f].values = new d[f].values.constructor(_)
      }
      for (var v = [], y = 0, h = 0; h < t.length; h++) {
        for (var p = t[0], s = 0; s < p.indices.length; s++)
          v.push(p.indices[s] + y);
        y += p.attributes.position.values.length / 3
      }
      var C = Cesium.BoundingSphere.fromVertices(d.position.values);
      return new Cesium.Geometry({
        attributes: d,
        indices: new Int32Array(v),
        primitiveType: t[0].primitiveType,
        boundingSphere: C
      })
    },
    n.prototype.updateImagingAreaGeometry = function(t) {
      if (this._track.lastestFrame) {
        var e = this._track.lastestFrame.length != this._outlinePositions.length;
        if (!e)
          for (var i = 0; i < this._track.lastestFrame.length; i++)
            if (!this._track.lastestFrame[i].equals(this._outlinePositions[i])) {
              e = !0;
              break
            } if (!e) return
      }
      if (this._track.lastestFrame && this._track.lastestFrame.length == this._outlinePositions.length)
        for (var i = 0; i < this._outlinePositions.length; i++) this._outlinePositions[i].clone(this._track
          .lastestFrame[i]);
      else {
        this._track.lastestFrame = [];
        for (var i = 0; i < this._outlinePositions.length; i++)
          this._track.lastestFrame.push(this._outlinePositions[i].clone())
      }
      var n = this.updateImagingAreaGeometry2(t);
      if (this._trackGeometries.push(n), this._track.geometry) {
        var r = this._track.geometry.attributes;
        for (var i in r)
          r.hasOwnProperty(i) && delete r[i];
        for (var i in this._track.geometry)
          this._track.geometry.hasOwnProperty(i) && delete this._track.geometry[i]
      }
      this._track.geometry = this.mergeGeometries(this._trackGeometries),
        this._track.needsUpdate = !0
    };
  var g = new Cesium.Quaternion;
  n.prototype.computeMatrix = function(t, e) {
      if (this._positionCartesian || (this._positionCartesian = new Cesium.Cartesian3), this
        .position instanceof Cesium.Cartesian3 ? this._positionCartesian = this.position : "function" == typeof this
        .position.getValue ? this._positionCartesian = this.position.getValue(t) : this.position._value && this
        .position._value instanceof Cesium.Cartesian3 && (this._positionCartesian = this.position._value), !this
        ._positionCartesian)
        return this._matrix;
      if (this._modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(this._positionCartesian, a, this
          ._modelMatrix), this._positionCartographic = Cesium.Cartographic.fromCartesian(this._positionCartesian, a,
          this._positionCartographic), Cesium.Transforms.eastNorthUpToFixedFrame(this._positionCartesian, a, this
          ._modelMatrix), this.autoAngle && this._trackedEntity && this._trackedEntity.orientation) {
        var i = Cesium.Property.getValueOrUndefined(this._trackedEntity.orientation, t, g),
          n = Cesium.Matrix4.getHeadingPitchRollByOrientation(this._positionCartesian, i);
        this._rotation.heading = n.heading
      }
      return Cesium.Quaternion.fromHeadingPitchRoll(this._rotation, this._quaternion),
        this._matrix = Cesium.Matrix4.fromTranslationQuaternionRotationScale(this._translation, this._quaternion, this
          ._scale, this._matrix),
        Cesium.Matrix4.multiplyTransformation(this._modelMatrix, this._matrix, this._matrix),
        Cesium.Matrix4.inverseTransformation(this._matrix, this._inverseMatrix), this._matrix
    },
    n.prototype.exportImagingArea = function(t, e) {
      var i = this._outlinePositions;
      if (e) {
        if (this.computeMatrix(e), !this._positionCartesian)
          return;
        i = o(this._positions, this._matrix, 3, this._positions.length - 3, a, null, this._geometry.attributes
          .position.values)
      }
      for (var n = [], r = 0; r < i.length; r++) {
        var s = i[r];
        Cesium.Cartographic.fromCartesian(s, void 0, _);
        var l = [Cesium.Math.toDegrees(_.longitude), Cesium.Math.toDegrees(_.latitude)];
        t && (l[0] = parseFloat(l[0].toFixed(t)), l[1] = parseFloat(l[1].toFixed(t))), n.push(turf.point(l))
      }
      var h = [];
      if (n.length > 0) {
        n = turf.featureCollection(n);
        var d = turf.convex(n);
        if (d) {
          var m = turf.getCoords(d);
          m && m.length > 0 && (h = m[0])
        }
      }
      return h
    },
    n.prototype.updateImagingAreaGeometry2 = function(t) {
      for (var e = [], i = [], n = 0, r = 0; r < this._outlinePositions.length; r += 2) {
        var o = this._outlinePositions[0];
        e.push(o.x, o.y, o.z), i.push(n++)
      }
      return e = new Float32Array(e),
        i = new Int32Array(i), new Cesium.Geometry({
          attributes: {
            position: new Cesium.GeometryAttribute({
              componentDatatype: Cesium.ComponentDatatype.DOUBLE,
              componentsPerAttribute: 3,
              values: e
            })
          },
          primitiveType: Cesium.PrimitiveType.LINES,
          indices: i,
          boundingSphere: Cesium.BoundingSphere.fromVertices(e)
        })
    },
    n.prototype.remove = function() {
      this.viewer.scene.primitives.remove(this),
        this.groundAreaEntity && this.viewer.entities.remove(this.groundAreaEntity)
    },
    n.prototype.destroy = function(t) {
      if (t) {
        this.viewer.scene.primitives.remove(this),
          this.groundAreaEntity && this.viewer.entities.remove(this.groundAreaEntity),
          this._drawCommands.forEach(function(t) {
            t.vertexArray = t.vertexArray && t.vertexArray.destroy()
          }),
          this._drawCommands = [];
        for (var e in this._outlineGeometry.attributes)
          this._outlineGeometry.attributes.hasOwnProperty(e) && delete this._outlineGeometry.attributes[e];
        for (var e in this._geometry.attributes)
          this._geometry.attributes.hasOwnProperty(e) && delete this._geometry.attributes[e];
        delete this._outlineGeometry,
          delete this._geometry,
          delete this._positionCartesian,
          delete this._position,
          this._outlinePositions = []
      }
    },
    n.prototype.addToScene = function() {
      this.viewer.scene.primitives.add(this),
        this.groundAreaEntity && this.viewer.entities.add(this.groundAreaEntity)
    },
    n.prototype.updateGeometry = function() {
      this._areaType == n.AreaType.Cone ? (this._geometry = Cesium.CylinderGeometry.createGeometry(Cesium
            .CylinderGeometry.fromAngleAndLength(this._angle1, this._length, !0), this._matrix),
          this._outlineGeometry = Cesium.CylinderGeometry.createOutlineGeometry(Cesium.CylinderGeometry
            .fromAngleAndLength(this._angle1, this._length, !0))) : (this._geometry = FourPrismGeometry
          .createGeometry(FourPrismGeometry.fromAnglesLength(this._angle1, this._angle2, this._length, !0),
            this._matrix),
          this._outlineGeometry = FourPrismGeometry.createOutlineGeometry(FourPrismGeometry
            .fromAnglesLength(this._angle1, this._angle2, this._length, !0))),
        this._positions = new Float32Array(this._geometry.attributes.position.values.length);
      for (var t = 0; t < this._positions.length; t++)
        this._positions[t] = this._geometry.attributes.position.values[t];
      this._outlinePositions = []
    },
    n.prototype.updateVolumeGeometry = function() {
      var t = 1 + this._imagingAreaPositions.length,
        e = new Float32Array(3 + 3 * this._imagingAreaPositions.length),
        i = 0;
      e[i++] = this._positionCartesian.x,
        e[i++] = this._positionCartesian.y,
        e[i++] = this._positionCartesian.z;
      for (var n = 0; n < this._imagingAreaPositions.length; n++)
        e[i++] = this._imagingAreaPositions[n].x,
        e[i++] = this._imagingAreaPositions[n].y,
        e[i++] = this._imagingAreaPositions[n].z;
      for (var r = [], o = [], n = 1; n < t - 1; n++)
        r.push(0, n, n + 1),
        o.push(0, n);
      r = t >= 65535 ? new Uint32Array(r) : new Uint16Array(r);
      var a = {
          position: new Cesium.GeometryAttribute({
            componentDatatype: Cesium.ComponentDatatype.DOUBLE,
            componentsPerAttribute: 3,
            values: e
          })
        },
        s = Cesium.BoundingSphere.fromVertices(e),
        l = new Cesium.Geometry({
          attributes: a,
          indices: r,
          primitiveType: Cesium.PrimitiveType.TRIANGLES,
          boundingSphere: s
        }),
        h = new Cesium.Geometry({
          attributes: a,
          indices: new Uint32Array(o),
          primitiveType: Cesium.PrimitiveType.LINES,
          boundingSphere: s
        });
      (0, computeVertexNormals)(l),
      this._volumeGeometry = l,
        this._volumeOutlineGeometry = h
    },
    n.prototype.update = function(t) {
      if (this._show && (this.computeMatrix(t.time), this._positionCartesian)) {
        this._geometry || this.updateGeometry(),
          this._outlinePositions = o(this._positions, this._matrix, 3, this._positions.length - 3, a, this
            ._outlinePositions, this._geometry.attributes.position.values), this._imagingAreaPositions.splice(0, this
            ._imagingAreaPositions.length);
        var e = this.exportImagingArea();
        if (e && e.length) {
          for (var i = 0; i < e.length; i++) {
            var n = e[i];
            this._imagingAreaPositions.push(Cesium.Cartesian3.fromDegrees(n[0], n[1]))
          }
          t.mode === Cesium.SceneMode.SCENE3D ? (this.updateVolumeGeometry(), this._volumeGeometry && (this
              ._volumeCommand && (this._volumeCommand.vertexArray = this._volumeCommand.vertexArray && this
                ._volumeCommand.vertexArray.destroy(), this._volumeCommand = null),
              this._volumeCommand = this.createDrawCommand(this._volumeGeometry, t, Cesium.Matrix4.IDENTITY
                .clone()),
              t.commandList.push(this._volumeCommand),
              this._outline && (this._volumeOutlineCommand && (this._volumeOutlineCommand.vertexArray = this
                  ._volumeOutlineCommand.vertexArray && this._volumeOutlineCommand.vertexArray.destroy(), this
                  ._volumeOutlineCommand = null),
                this._volumeOutlineCommand = this.createDrawCommand(this._volumeOutlineGeometry, t, Cesium.Matrix4
                  .IDENTITY.clone()),
                t.commandList.push(this._volumeOutlineCommand))),
            this.groundAreaEntity && (this.groundAreaEntity.polygon.show = this._groundArea && this._show, this
              .groundAreaEntity.polyline.show = this._groundOutLine && this._show)) : (this.groundAreaEntity || this
            .addGroundAreaEntity(!0), this.groundAreaEntity.polygon.show = !0)
        } else
          this._outline && (this._outlineGeometry._drawCommand || (this._outlineGeometry._drawCommand = this
            .createDrawCommand(this._outlineGeometry, t)), t.commandList.push(this._outlineGeometry._drawCommand)),
          this.groundAreaEntity && (this.groundAreaEntity.polygon.show = !1, this.groundAreaEntity.polyline.show = !1)
      }
    },
    n.prototype.getFragmentShaderSource = function(t) {
      return `
        #define FACE_FORWARD
        varying vec3 v_position;
        varying vec3 v_normal;
        uniform float picked;
        uniform vec4  pickedColor;
        uniform vec4  defaultColor;
        uniform float specular;
        uniform float shininess;
        uniform vec3  emission;
        varying vec2 v_st;
        uniform bool isLine;
        uniform float glowPower;
        void main() {
            vec3 positionToEyeEC = -v_position;
            vec3 normalEC =normalize(v_normal);
            normalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);
            vec4 color=defaultColor;
            if(picked!=0.0){
                color = pickedColor;
            }
            if(v_st.x<0.5){
              color.a = color.a*( 0.75-v_st.x);
            }else{
              color.a =color.a*(v_st.x-0.25);
            }
            czm_material material;
            material.specular = specular;
            material.shininess = shininess;
            material.normal =  normalEC;
            material.emission = emission;
            //vec3(0.2,0.2,0.2);
            material.diffuse = color.rgb;

            // float glow = glowPower / abs(v_st.t  ) - (glowPower / 0.5);
            if(isLine){
                // material.alpha = clamp(0.0, 1.0, glow) * color.a;
                material.alpha = 1.0;
            }else{
               material.alpha = color.a;
            }

            // material.emission = max(vec3(glow - 1.0 + color.rgb), color.rgb);

            if(v_st.x==0.0){
              gl_FragColor =color;
            }else {
              vec3 toEye = normalize(positionToEyeEC);
              // gl_FragColor = color;//czm_phong(toEye, material) ;
              gl_FragColor = czm_phong(toEye, material, czm_lightDirectionEC);
            }
        }`
    },
    // n.prototype.getVertexShaderSource = function (t) { return `\n#ifdef GL_ES\n
    //   precision highp float;\n#endif\n\nattribute vec3 position;\nattribute vec2 st;\n
    //   attribute vec3 normal;\nuniform mat4 modelViewMatrix;\nuniform mat3 normalMatrix;\n
    //   uniform mat4 projectionMatrix;\nvarying vec3 v_position;\nvarying vec3 v_normal;\n
    //   varying vec2 v_st;\n\nvarying vec3 v_light0Direction;\n\nvoid main(void) \n{\n
    //   vec4 pos =  modelViewMatrix * vec4( position,1.0);\n
    //   v_normal =  normalMatrix *  normal;\n    v_st = st;\n    v_position = pos.xyz;\n
    //   v_light0Direction = mat3( modelViewMatrix) * vec3(1.0,1.0,1.0);\n    gl_Position =  projectionMatrix * pos;\n}`
    // },
    n.prototype.getVertexShaderSource = function(t) {
      return `
        #ifdef GL_ES\n
          precision highp float;
        #endif\n
        attribute vec3 position;
        attribute vec2 st;
        attribute vec3 normal;
        uniform mat4 modelViewMatrix;
        uniform mat3 normalMatrix;
        uniform mat4 projectionMatrix;
        varying vec3 v_position;
        varying vec3 v_normal;
        varying vec2 v_st;
        varying vec3 v_light0Direction;
        void main(void) {
          vec4 pos =  modelViewMatrix * vec4(position,1.0);
          v_normal =  normalMatrix * normal;
          v_st = st;
          v_position = pos.xyz;
          v_light0Direction = mat3(modelViewMatrix) * vec3(1.0,1.0,1.0);
          gl_Position =  projectionMatrix * pos;
        }
        `
    },
    n.prototype.createDrawCommand = function(t, e, i) {
      var n = e.context,
        r = new Cesium.Cartesian3;
      Cesium.Matrix4.multiplyByPoint(this._matrix, t.boundingSphere.center, r);
      var o = (new Cesium.BoundingSphere(r, t.boundingSphere.radius), new Cesium.DrawCommand({
          modelMatrix: i || this._matrix,
          owner: this,
          primitiveType: t.primitiveType,
          pass: Cesium.Pass.OPAQUE
        })),
        a = this,
        s = Cesium.GeometryPipeline.createAttributeLocations(t);
      return o.vertexArray = Cesium.VertexArray.fromGeometry({
          context: n,
          geometry: t,
          attributeLocations: s,
          bufferUsage: Cesium.BufferUsage.STATIC_DRAW
        }),
        o.vertexArray._attributeLocations = s,
        o.shaderProgram = Cesium.ShaderProgram.replaceCache({
          context: n,
          vertexShaderSource: this.getVertexShaderSource(t),
          fragmentShaderSource: this.getFragmentShaderSource(t),
          attributeLocations: s
        }),
        o.renderState = Cesium.RenderState.fromCache({
          blending: Cesium.BlendingState.ALPHA_BLEND,
          depthTest: {
            enabled: !0,
            func: Cesium.DepthFunction.LESS
          },
          cull: {
            enabled: !1,
            face: Cesium.CullFace.BACK
          },
          depthMask: !1
        }),
        o.uniformMap = {},
        o.uniformMap.projectionMatrix = function() {
          return e.context.uniformState.projection
        },
        o.uniformMap.modelViewMatrix = function() {
          return e.context.uniformState.modelView
        },
        o.uniformMap.shininess = function() {
          return a.shininess || (a.shininess = 0), a.shininess
        },
        o.uniformMap.emission = function() {
          return a.emission || (a.emission = new Cesium.Cartesian3(.2, .2, .2)), a.emission
        },
        o.uniformMap.specular = function() {
          return a.specular || (a.specular = 0), a.specular
        },
        o.uniformMap.isLine = function() {
          return t.primitiveType == Cesium.PrimitiveType.LINES
        },
        o.uniformMap.defaultColor = function() {
          return t.color ? t.color : t.primitiveType == Cesium.PrimitiveType.LINES ? a.defaultLineColor || a
            .defaultColor || new Cesium.Color(1, 1, 0, .5) : a.defaultColor || new Cesium.Color(1, 0, 0, 1)
        },
        o.uniformMap.picked = function() {
          return a.picked || (a.picked = 0), a.picked
        },
        o.uniformMap.pickedColor = function() {
          return a.pickedColor || (a.pickedColor = new Cesium.Color(1, 1, 0, 1)), a.pickedColor
        },
        o.uniformMap.normalMatrix = function() {
          return e.context.uniformState.normal
        },
        o.uniformMap.glowPower = function() {
          return .25
        },
        o
    },
    extend2CartesianArray = o, SatelliteCoverageSimulation = n
})()

export {
  extend2CartesianArray,
  SatelliteCoverageSimulation
};
